home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et3_0-a1.lha / et3 / src / GraphView.C < prev    next >
C/C++ Source or Header  |  1992-06-02  |  13KB  |  610 lines
  1. #ifdef __GNUG__
  2. #pragma implementation
  3. #endif
  4.  
  5. #include "GraphView.h"
  6.  
  7. #include "Class.h"
  8. #include "ObjList.h"
  9. #include "IdDictionary.h"
  10. #include "OrdColl.h"
  11. #include "Dialog.h"
  12. #include "TextItem.h"
  13. #include "Math.h"
  14.  
  15. //---- GraphNode -------------------------------------------------------------
  16.  
  17. NewMetaImpl(GraphNode, TreeNode, (TP(constrainingNodes), TP(nonTreeOutEdges), T(inEdges)));
  18.  
  19. GraphNode::GraphNode(int id, Collection *cp) : TreeNode(id, cp)
  20. { 
  21.     constrainingNodes= 0; 
  22.     nonTreeOutEdges= 0;
  23.     inEdges= 0; 
  24. }
  25.  
  26. GraphNode::~GraphNode()
  27. {
  28.     SafeDelete(nonTreeOutEdges);
  29.  
  30.     // clean up contents of GraphNode to avoid duplicate deletes from 
  31.     // CompositeVObject::~CompositeVObject
  32.     if (Size() > 1) {
  33.     Iter next(GetList());
  34.     next();    // skip first
  35.     Object *op;
  36.     while (op= next())
  37.         GetList()->RemovePtr(op);
  38.     }
  39. }
  40.  
  41. VObject *GraphNode::Image()
  42. {
  43.     if (Size() > 0)
  44.     return At(0);
  45.     return 0;
  46. }
  47.  
  48. int GraphNode::CalcShift()
  49. {
  50.     Point origin= contentRect.origin;
  51.     
  52.     if (InCalcShift()) {
  53.     Warning("CalcShift", "cycle in graph");
  54.     return contentRect.origin.x;
  55.     }
  56.     SetFlag(eGraphInCalc);
  57.     if (!IsPositionSet()) {
  58.     SetFlag(eGraphPosSet); 
  59.     if (constrainingNodes) {
  60.         Iter next(constrainingNodes->MakeIterator());
  61.         GraphNode *gp;
  62.         while (gp= (GraphNode*)next()) 
  63.         origin.x= Math::Max(origin.x, gp->CalcShift());
  64.         //if (origin.x != contentRect.origin.x)
  65.         origin.x += 2*(Gap().x);
  66.     }
  67.     SafeDelete(constrainingNodes);
  68.     }
  69.     if (origin != contentRect.origin)
  70.     SetOrigin(origin);   
  71.         
  72.     ResetFlag(eGraphInCalc);
  73.     return contentRect.origin.x+contentRect.extent.x;
  74. }
  75.  
  76. void GraphNode::AddNonTreeOutEdge(GraphNode *gp)
  77. {
  78.     if (nonTreeOutEdges == 0)
  79.     nonTreeOutEdges= new OrdCollection;
  80.     nonTreeOutEdges->Add(gp);
  81. }
  82.  
  83. void GraphNode::AddConstrainingNode(GraphNode *gp)
  84. {
  85.     if (constrainingNodes == 0)
  86.     constrainingNodes= new OrdCollection;
  87.     constrainingNodes->Add(gp);
  88. }
  89.  
  90. void GraphNode::AddNode(VObject *vp)
  91. {
  92.     Add(vp);
  93. }
  94.  
  95. void GraphNode::Draw(Rectangle r)
  96. {
  97.     Image()->DrawAll(r, FALSE);
  98. }
  99.  
  100. void GraphNode::DrawConnections()
  101. {
  102.     TreeNode::DrawConnections();
  103.     if (nonTreeOutEdges) {
  104.     VObject *image= Image();
  105.     Point p1= image->contentRect.E();
  106.     Iter next(nonTreeOutEdges);
  107.     GraphNode *gp;
  108.     while (gp= (GraphNode*)next()) 
  109.         GrLine(p1, gp->Image()->contentRect.W());
  110.     }
  111. }
  112.  
  113. void GraphNode::Export(OStream &s)
  114. {
  115.     // leave node
  116.     if ((Size() + (nonTreeOutEdges ? nonTreeOutEdges->Size() : 0)) == 1)
  117.     return;
  118.     
  119.     GraphNode *gp;
  120.     int i= 0;
  121.     if (Size() > 0) {
  122.     Iter next1(MakeIterator());
  123.     while (gp= (GraphNode*)next1()) {
  124.         if (i++ == 0) // the image of the node itself
  125.         s << gp->AsString() << ": "; 
  126.         else
  127.         s << gp->Image()->AsString() SP;
  128.     } 
  129.     } 
  130.     if (nonTreeOutEdges) {
  131.     Iter next2(nonTreeOutEdges);
  132.     while (gp= (GraphNode*)next2()) 
  133.         s << gp->Image()->AsString() SP;
  134.     }
  135.     s NL;
  136. }
  137.  
  138. //---- GraphNodeMover -------------------------------------------------------------
  139.  
  140. class GraphNodeMover: public Command {
  141.     GraphView *gvp;
  142.     GraphNode *gnp;
  143.     VObject *item;
  144.     GrCursor oldcursor;
  145.     Point delta;
  146. public:
  147.     GraphNodeMover(GraphView *g, GraphNode *v) : Command(cIdNone, "move node")
  148.     { gvp= g; gnp= v; item= gnp->Image(); delta= 0; }
  149.     void TrackFeedback(Point, Point, bool);
  150.     Command *TrackMouse(TrackPhase, Point, Point, Point);
  151.     void DoIt();
  152.     void UndoIt();
  153. };
  154.  
  155. void GraphNodeMover::TrackFeedback(Point anchorPoint, Point nextPoint, bool)
  156. {
  157.     item->Outline(nextPoint - anchorPoint);
  158. }
  159.  
  160. Command *GraphNodeMover::TrackMouse(TrackPhase tp, Point ap, Point, Point np)
  161. {
  162.     switch (tp) {
  163.     case eTrackPress:
  164.     oldcursor= GrGetCursor();
  165.     break;
  166.     case eTrackMove:
  167.     GrSetCursor(eCrsMoveHand);
  168.     break;
  169.     case eTrackRelease:
  170.     delta= np-ap;
  171.     GrSetCursor(oldcursor);
  172.     break;
  173.     default:
  174.     break;
  175.     }
  176.     return this;
  177.  
  178. }
  179.  
  180. void GraphNodeMover::DoIt()
  181. {
  182.     item->Move(delta);
  183.     gnp->contentRect+= delta;
  184.     gvp->CalcExtent();
  185.     gvp->ForceRedraw();
  186. }
  187.  
  188. void GraphNodeMover::UndoIt()
  189. {
  190.     item->Move(-delta);
  191.     gnp->contentRect-= delta;
  192.     gvp->CalcExtent();
  193.     gvp->ForceRedraw();
  194. }
  195.  
  196. //---- GraphView -----------------------------------------------------------------
  197.  
  198. NewMetaImpl(GraphView, TreeView, (TP(nodes), TP(paths), TP(refs)));
  199.  
  200. GraphView::GraphView(EvtHandler *dp) : TreeView(dp)
  201. {
  202.     nodes= new IdDictionary; 
  203.     connType= eTCDiagonal;
  204.     paths= new OrdCollection;
  205.     refs= new OrdCollection;
  206. }
  207.  
  208. GraphView::~GraphView()
  209. {
  210.     if (nodes) {
  211.     nodes->FreeValues();
  212.     SafeDelete(nodes);
  213.     }
  214.     SafeDelete(paths);
  215.     SafeDelete(refs);
  216. }
  217.  
  218. void GraphView::Draw(Rectangle r)
  219. {
  220.     DictionaryIterator it(nodes);
  221.     register GraphNode *np= 0;
  222.     
  223.     View::Draw(r);
  224.     if (connType != eTCNone) {
  225.     while (np= (GraphNode*)it.NextValue()) 
  226.         np->DrawConnections();
  227.     }
  228.     
  229.     DrawPaths(r);
  230.     DrawReferences(r);
  231.         
  232.     it.Reset();
  233.     while (np= (GraphNode*)it.NextValue()) {
  234.     VObject *vp= np->Image();
  235.     if (vp && vp->contentRect.Intersects(r))
  236.         vp->DrawAll(r, vp == GetSelection());
  237.     }
  238. }
  239.  
  240. void GraphView::SetConnType(TreeConnection ct)
  241. {
  242.     if (ct != eTCNone && ct != eTCDiagonal)
  243.     return;  
  244.     connType= ct;
  245.     ForceRedraw();  
  246. }
  247.  
  248. GraphNode *GraphView::FindNode(Point lp)
  249. {
  250.     DictionaryIterator it(nodes);
  251.     GraphNode *np= 0;
  252.     
  253.     while (np= (GraphNode*)it.NextValue()) {
  254.     VObject *vp= np->Image();
  255.     if (vp->ContainsPoint(lp))
  256.         return np;
  257.     } 
  258.     return 0;  
  259. }
  260.  
  261. Command *GraphView::DoLeftButtonDownCommand(Point lp, Token, int cl)
  262. {
  263.     GraphNode *np= FindNode(lp);
  264.     if (np)
  265.     return new TreeNodeSelector(np, cl);
  266.     return gNoChanges;  
  267. }
  268.  
  269. Command *GraphView::DoMiddleButtonDownCommand(Point lp, Token, int)
  270. {
  271.     GraphNode *np= FindNode(lp);
  272.     if (np)
  273.     return new GraphNodeMover(this, np);
  274.     return gNoChanges;  
  275. }
  276.  
  277. void GraphView::CalcExtent()
  278. {
  279.     DictionaryIterator it(nodes);
  280.     register GraphNode *np= 0;
  281.     Rectangle r;
  282.     
  283.     while (np= (GraphNode*)it.NextValue()) 
  284.     r.Merge(np->Image()->contentRect);
  285.     SetExtent(r.extent+Point(200)); 
  286. }
  287.  
  288. Iterator *GraphView::MakeSubPartsIter(Object *)
  289. {
  290.     AbstractMethod("MakeSubPartsIter");
  291.     return 0;  
  292. }
  293.  
  294. Iterator *GraphView::MakeChildrenIter(Object *op)
  295. {
  296.     return MakeSubPartsIter(op);
  297. }
  298.  
  299. VObject *GraphView::DoCreateRoot()
  300. {
  301.     return new TextItem("Root");
  302. }
  303.  
  304. VObject *GraphView::DoCreateDialog()
  305. {
  306.     return 0;
  307. }
  308.  
  309. VObject *GraphView::AssociatedVObject(Object *op)
  310. {
  311.     GraphNode *gp= (GraphNode*) nodes->AtKey(op);
  312.     if (gp)
  313.     return gp->Image();
  314.     return 0;      
  315. }
  316.     
  317. GraphNode *GraphView::AssociatedGraphNode(Object *op)
  318. {
  319.     return (GraphNode*) nodes->AtKey(op);
  320. }
  321.  
  322. void GraphView::SetGraph(GraphNode *root, bool)
  323. {
  324.     DictionaryIterator it(nodes);
  325.     GraphNode *np= 0;
  326.     
  327.     while (np= (GraphNode*)it.NextValue()) {
  328.     np->SetContainer(this);
  329.     np->Enable();
  330.     }
  331.     // calculate tree layout
  332.     root->CalcExtent();
  333.     root->SetOrigin(GetOrigin());
  334.     it.Reset();
  335.     while (np= (GraphNode*)it.NextValue()) 
  336.     np->CalcShift();
  337.     CalcExtent();
  338.     ForceRedraw();
  339. }
  340.  
  341. void GraphView::EmptyGraph()
  342. {
  343.     SetSelection(0);
  344.     nodes->FreeValues();
  345.     nodes->Empty(0);
  346. }
  347.  
  348. GraphNode *GraphView::BuildGraphDFS(Object *np)
  349. {
  350.     Object *subNode;
  351.     GraphNode *gp;
  352.     
  353.     if (gp= (GraphNode*) nodes->AtKey(np)) 
  354.     return gp;
  355.     
  356.     GraphNode *node= new GraphNode;
  357.     node->AddNode(NodeAsVObject(np));
  358.     nodes->PutAtKeyIfAbsent(node, np); // register node in dictionary
  359.     Iterator *it= MakeSubPartsIter(np);
  360.     
  361.     if (it) {
  362.     Iter next(it);
  363.     
  364.     while (subNode= next()) {            
  365.         // node already occurred hence must be a nonTreeOutEdge
  366.         if (gp= (GraphNode*) nodes->AtKey(subNode)) { // node already occurred, -> nonTreeOutEdge
  367.         node->AddNonTreeOutEdge(gp);
  368.         gp->AddConstrainingNode(node);
  369.         } else {
  370.         gp= BuildGraphDFS(subNode);
  371.         node->AddNode(gp);
  372.         }
  373.         gp->AddInEdge(node);
  374.     }
  375.     }
  376.     return node;    
  377. }   
  378.  
  379. void GraphView::BuildGraphBFS(Object *op)
  380. {
  381.     ObjList q;          // queue for breadth first search
  382.     GraphNode *gnp, *snp;
  383.     Object *subnode, *node;
  384.     
  385.     q.Add(op);
  386.     while (q.Size() > 0) {
  387.     node= q.RemoveFirst();
  388.     if ((gnp= (GraphNode*) nodes->AtKey(node)) == 0) {
  389.         gnp= new GraphNode;
  390.         nodes->PutAtKeyIfAbsent(gnp, node);
  391.         gnp->AddNode(NodeAsVObject(node));
  392.     }
  393.     Iterator *it= MakeSubPartsIter(node);
  394.     if (it) {
  395.         Iter next(it);
  396.         while (subnode= next()) {
  397.         // node was already visited
  398.         if (snp= (GraphNode*)nodes->AtKey(subnode)) {
  399.             gnp->AddNonTreeOutEdge(snp);
  400.             snp->AddConstrainingNode(gnp);
  401.         } else {
  402.             snp= new GraphNode();
  403.             snp->AddNode(NodeAsVObject(subnode));
  404.             gnp->AddNode(snp);
  405.             nodes->PutAtKeyIfAbsent(snp, subnode);
  406.             q.Add(subnode);
  407.         }
  408.         snp->AddInEdge(gnp);
  409.         }
  410.     }
  411.     }
  412. }   
  413.  
  414. GraphNode *GraphView::FindRoot()
  415. {
  416.     OrdCollection *oc= new OrdCollection();    
  417.     DictionaryIterator it(nodes);
  418.     GraphNode *np= 0, *root;
  419.  
  420.     while (np= (GraphNode *)it.NextValue())
  421.     if (np->NumInEdges() == 0)
  422.         oc->Add(np);
  423.         
  424.     if (oc->Size() == 1) {
  425.     root= (GraphNode*)oc->First();
  426.     SafeDelete(oc);
  427.     return root;
  428.     }
  429.     // create artificial root
  430.     VObject *vop= DoCreateRoot();
  431.     oc->AddFirst(vop);
  432.     root= new GraphNode(cIdNone, oc);
  433.     nodes->PutAtKeyIfAbsent(root, vop); 
  434.     return root;
  435. }
  436.  
  437. void GraphView::DrawPaths(Rectangle r)
  438. {
  439.     Iter next(paths);
  440.     GraphPath *gp;
  441.     while (gp= (GraphPath*)next()) 
  442.     gp->Draw(r);
  443. }
  444.  
  445. void GraphView::AddPath(GraphPath *p)
  446. {
  447.     paths->Add(p);
  448.     InvalidateRect(p->BBox());
  449. }
  450.  
  451. GraphPath *GraphView::RemovePath(GraphPath *p)
  452. {
  453.     GraphPath *gp;
  454.     gp= (GraphPath*)paths->RemovePtr(p);
  455.     if (gp)
  456.     InvalidateRect(p->BBox());
  457.     return gp;
  458. }
  459.  
  460. void GraphView::RemoveAllPaths()
  461. {
  462.     paths->FreeAll();
  463.     paths->Empty(0);
  464.     ForceRedraw();
  465. }
  466.  
  467. void GraphView::DrawReferences(Rectangle r)
  468. {
  469.     Iter next(refs);
  470.     GraphReference *gp;
  471.     while (gp= (GraphReference*)next()) 
  472.     gp->Draw(r);
  473. }
  474.  
  475. void GraphView::AddReference(GraphReference *p)
  476. {
  477.     refs->Add(p);
  478.     InvalidateRect(p->BBox());
  479. }
  480.  
  481. GraphReference *GraphView::RemoveReference(GraphReference *p)
  482. {
  483.     GraphReference *gp;
  484.     gp= (GraphReference*)refs->RemovePtr(p);
  485.     if (gp)
  486.     InvalidateRect(p->BBox());
  487.     return gp;
  488. }
  489.  
  490. void GraphView::RemoveAllReferences()
  491. {
  492.     refs->FreeAll();
  493.     refs->Empty(0);
  494.     ForceRedraw();
  495. }
  496.  
  497. //---- GraphPath ------------------------------------------------------------
  498.  
  499. GraphPath::GraphPath(GraphView *g, Collection *n, Ink *i, int w, bool f)
  500. {
  501.     nodes= n;
  502.     free= f;
  503.     gvp= g;
  504.     width= w;
  505.     ink= i;
  506. }
  507.         
  508. GraphPath::~GraphPath()
  509. {
  510.     if (free)
  511.     SafeDelete(nodes);
  512. }
  513.     
  514. void GraphPath::Draw(Rectangle)
  515. {
  516.     Object *op;
  517.     VObject *image;
  518.     Iter next(nodes);
  519.  
  520.     for (int i= 0; op= next(); i++) {
  521.     image= gvp->AssociatedVObject(op);
  522.     if (!image)
  523.         continue;//Error("Draw", "node in GraphPath without representation");
  524.     GrSetPenNormal();
  525.     GrStrokeRect(image->contentRect.Expand(1));
  526.     GrSetPenSize(width);
  527.     GrSetPenInk(ink);
  528.     if (i == 0)
  529.         GrMoveto(image->contentRect.Center());
  530.     else
  531.         GrLineto(image->contentRect.Center());
  532.     }
  533. }
  534.  
  535. Rectangle GraphPath::BBox()
  536. {
  537.     Rectangle r;
  538.     Object *op;
  539.     VObject *image;
  540.     Iter next(nodes);
  541.     while (op= next()) 
  542.     if (image= gvp->AssociatedVObject(op))
  543.         r.Merge(image->contentRect.Expand(4));
  544.     return r;
  545. }
  546.  
  547. //---- GraphReference ------------------------------------------------------------
  548.  
  549. GraphReference::GraphReference(GraphView *g, Object *op, Collection *n, Ink *i, int w, bool f)
  550. {
  551.     nodes= n;
  552.     free= f;
  553.     gvp= g;
  554.     width= w;
  555.     ink= i;
  556.     referto= op;
  557. }
  558.         
  559. GraphReference::~GraphReference()
  560. {
  561.     if (free)
  562.     SafeDelete(nodes);
  563. }
  564.     
  565. void GraphReference::Draw(Rectangle)
  566. {
  567.     Object *op;
  568.     VObject *image, *opimage;
  569.  
  570.     Iter next(nodes);
  571.     opimage= gvp->AssociatedVObject(referto);
  572.     if (!opimage)
  573.     return;
  574.     GrSetPenNormal();
  575.     GrStrokeRect(opimage->contentRect.Expand(1)); 
  576.        
  577.     for (int i= 0; op= next(); i++) {
  578.     image= gvp->AssociatedVObject(op);
  579.     if (!image)
  580.         continue;
  581.     GrSetPenNormal();
  582.     GrStrokeRect(image->contentRect.Expand(1));
  583.     DrawConnection(i, opimage, image);
  584.     }
  585. }
  586.  
  587. void GraphReference::DrawConnection(int, VObject *from, VObject *to)
  588. {
  589.     GrSetPenSize(width);
  590.     GrSetPenInk(ink);
  591.     GrLine(from->contentRect.Center(), to->contentRect.Center());
  592. }
  593.  
  594. Rectangle GraphReference::BBox()
  595. {
  596.     Rectangle r;
  597.     Object *op;
  598.     VObject *image, *opimage;
  599.     Iter next(nodes);
  600.   
  601.     opimage= gvp->AssociatedVObject(referto);
  602.     while (opimage && (op= next())) {
  603.     if (image= gvp->AssociatedVObject(op)) {
  604.         r.Merge(opimage->contentRect.Expand(4));
  605.         r.Merge(image->contentRect.Expand(4));
  606.     }
  607.     }
  608.     return r;
  609. }
  610.